<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>es6-2</title>
</head>

<body>

</body>
<script>
    // Promise：是es6引入的异步编程新的解决方案。用来封装异步操作并且可以获取其成功或者失败的结果,promise是一个对象，
    // 对象和函数的区别就是对象可以保存状态，函数不可以（闭包除外）

    // const p = new Promise((resolve, reject) => {
    //     setTimeout(() => {
    //         const data = '大奥古斯'
    //         resolve(data)
    //     }, 4000)
    // }).then((value) => {
    //     console.log(value)
    // }, (reason) => {
    //     console.log(reason)
    // })
    //promise有三个状态：
    // 1、pending[待定]初始状态
    // 2、fulfilled[实现]操作成功
    // 3、rejected[被否决]操作失败
    // Promise含有两个参数，resolve, reject。
    // resolve作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），
    // 在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；
    // reject作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），
    // 在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
    // 当promise状态发生改变，就会触发then()里的响应函数处理后续步骤；promise状态一经改变，不会再变。

    // const p = new Promise((resolve, reject) => {
    //   setTimeout(() => {
    //     const data = "大奥古斯";
    //     resolve(data);
    //   }, 4000);
    // }).catch((reason)=>{
    //   console.log(reason)
    // })
    //错误可以用catch进行抓取


    // set:ES6提供了新的数据结构set（集合），它类似于数组，但成员的值都是唯一的，集合实现了 iterator接口，
    // 所以可以使用扩展运算符和for of进行遍历，
    // 集合的属性和方法：(1)size: 返回集合的个数，
    // (2)add: 增加一个新元素，返回当前集合，
    // (3)delete：删除元素，返回布尔值，
    // (4)has：检测集合中是否包含某个元素，返回布尔值

    //声明一个set
    // let se = new Set();
    // let se2 = new Set(["da", "xiao", "gao", "pang"]);
    // console.log(se2);
    // //添加新元素
    // se2.add("xishi");
    // console.log(se2);
    // //删除元素
    // se2.delete("gao");
    // console.log(se2);
    // //检测
    // console.log(se2.has("da"));
    // //清空
    // se2.clear();
    // console.log(se2);

    // set: ES6提供了数据结构Map，它类似于对象，也是键值对的集合
    // 但键的范围不限于字符串，各种类型的值（包括对象）都可以当做键
    // Map也实现了iterator接口，所以可以使用扩展运算符和for of进行遍历
    // Map的属性和方法
    //     (1)size: 返回Map元素的个数
    //     (2)set: 增加一个新元素，返回当前Map
    //     (3)get：返回键名对象的键值
    //     (4)has：检测Map中是否包含某个元素，返回布尔值
    //     (5)clear: 清空集合，返回undefined

    //声明一个Map
    // let m = new Map();
    // console.log(m);
    // m.set("name", "zmy");
    // console.log(m);
    // m.set("change", function () {
    //     console.log(11111);
    // });
    // console.log(m);
    // let key = {
    //     school: "ahgy",
    // };
    // m.set(key, "mm");
    // console.log(m);
    // //size
    // console.log(m.size);
    //其中键值可以是字符串，也可以是对象

    // class类：通过class，可以定义类。基本上es6中可以看作是一个语法糖
    //     新的class写法只是让对象原型的写法更加清晰、更加面向对象编程的语法而已
    //         (1)class声明类，
    //         (2)constructor定义构造函数初始化，当使用new 方法名()，就会执行constructor
    //         (3)extends继承父类，
    //         (4)super调用父级构造方法，
    //         (5)static定义静态方法和属性，
    //         (6)父类方法可以重写

    // class phone {
    //     //构造方法，名字不能修改
    //     constructor(price, name) {
    //         this.price = price;
    //         this.name = name;
    //     }
    //     //方法必须使用该语法，不能使用es5对象完整形式call：function{}
    //     call() {
    //         console.log("打电话");
    //     }
    // }
    // let oneplus = new phone(2000, "华为");
    // console.log(oneplus);

    // 静态成员
    // class phone {
    //     static num = 123
    //     static change() {
    //         console.log('我可以改变世界')
    //     }
    // }


    // 构造函数继承
    // class Phone {
    //     //构造方法
    //     constructor(price, name) {
    //         this.price = price
    //         this.name = name
    //     }
    //     calll() {
    //         console.log('我可以改变世界')
    //     }
    // }
    // class smallcall extends Phone {
    //     //构造方法
    //     constructor(price, name, color, size) {
    //         super(price, name) //调用父类的constructor方法
    //         this.color = color
    //         this.size = size
    //     }
    //     photo() {
    //         console.log('111')
    //     }
    // }
    // const mi = new smallcall(133, '小米', 'red', 4.7)
    // console.log(mi);


    // 数值扩展
    // 1.Number.EPSILON: 是JavaScript表示的最小精度

    // 2.Number.isNaN: 检测一个值是否为NaN

    // 3.Number.isInteger: 判断一个数是否为整数

    // 4.Math.trunc: 将数字的小数部分抹掉

    // 对象方法扩展
    // 1.Object.is: 判断两个值是否相等
    // 2.Object.assign: 对象的合并
    // 3.Object.setPrototypeOf: 设置原型对象


    // Es6模块化
    // 1.分别暴露：就是在每个需要暴露的变量前加export
    // export let mi = 'xiaomi'
    // export function name() {
    //     console.log(111)
    // }
    // 2.统一暴露
    // let mi = 'xiaomi'
    // function name() {
    //     console.log(111)
    // }
    // export { mi, name }

    // 3.默认暴露

    // // 
    // export default {
    //     mi: 'xiaomi',
    //     name: function {

    //     }
    // }


    // 引入模块
    // 1.通用导入模块：import * as m from ‘/xx.js’,其中用as定义别名为m。

    // 2.解构赋值：import { a, b as c } from ‘/xx.js’ 如果多个引入的值中有重复的会报错，可以用as如把b的值换成c，在默认暴露default的引入中：import { default as s2}，不能使用default，需要用as把default重定义一个值s2

    // 3.只有默认暴露可以使用简便的方法：import m from ‘/xx.js’



    // ES7部分特性
// 1.includes：检测数组中是否包含某个元素，返回值是布尔值
// 2.指数操作符：**




</script>

</html>